home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / test / test_compile.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2005-10-18  |  10.3 KB  |  321 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. import unittest
  5. import warnings
  6. import sys
  7. from test import test_support
  8.  
  9. class TestSpecifics(unittest.TestCase):
  10.     
  11.     def test_debug_assignment(self):
  12.         self.assertRaises(SyntaxError, compile, '__debug__ = 1', '?', 'single')
  13.         import __builtin__
  14.         prev = __builtin__.__debug__
  15.         setattr(__builtin__, '__debug__', 'sure')
  16.         setattr(__builtin__, '__debug__', prev)
  17.  
  18.     
  19.     def test_argument_handling(self):
  20.         self.assertRaises(SyntaxError, eval, 'lambda a,a:0')
  21.         self.assertRaises(SyntaxError, eval, 'lambda a,a=1:0')
  22.         self.assertRaises(SyntaxError, eval, 'lambda a=1,a=1:0')
  23.         
  24.         try:
  25.             exec 'def f(a, a): pass'
  26.             self.fail('duplicate arguments')
  27.         except SyntaxError:
  28.             pass
  29.  
  30.         
  31.         try:
  32.             exec 'def f(a = 0, a = 1): pass'
  33.             self.fail('duplicate keyword arguments')
  34.         except SyntaxError:
  35.             pass
  36.  
  37.         
  38.         try:
  39.             exec 'def f(a): global a; a = 1'
  40.             self.fail('variable is global and local')
  41.         except SyntaxError:
  42.             pass
  43.  
  44.  
  45.     
  46.     def test_syntax_error(self):
  47.         self.assertRaises(SyntaxError, compile, '1+*3', 'filename', 'exec')
  48.  
  49.     
  50.     def test_duplicate_global_local(self):
  51.         
  52.         try:
  53.             exec 'def f(a): global a; a = 1'
  54.             self.fail('variable is global and local')
  55.         except SyntaxError:
  56.             pass
  57.  
  58.  
  59.     
  60.     def test_exec_with_general_mapping_for_locals(self):
  61.         
  62.         class M:
  63.             '''Test mapping interface versus possible calls from eval().'''
  64.             
  65.             def __getitem__(self, key):
  66.                 if key == 'a':
  67.                     return 12
  68.                 
  69.                 raise KeyError
  70.  
  71.             
  72.             def __setitem__(self, key, value):
  73.                 self.results = (key, value)
  74.  
  75.             
  76.             def keys(self):
  77.                 return list('xyz')
  78.  
  79.  
  80.         m = M()
  81.         g = globals()
  82.         exec 'z = a' in g, m
  83.         self.assertEqual(m.results, ('z', 12))
  84.         
  85.         try:
  86.             exec 'z = b' in g, m
  87.         except NameError:
  88.             pass
  89.  
  90.         self.fail('Did not detect a KeyError')
  91.         exec 'z = dir()' in g, m
  92.         self.assertEqual(m.results, ('z', list('xyz')))
  93.         exec 'z = globals()' in g, m
  94.         self.assertEqual(m.results, ('z', g))
  95.         exec 'z = locals()' in g, m
  96.         self.assertEqual(m.results, ('z', m))
  97.         
  98.         try:
  99.             exec 'z = b' in m
  100.         except TypeError:
  101.             pass
  102.  
  103.         self.fail('Did not validate globals as a real dict')
  104.         
  105.         class A:
  106.             '''Non-mapping'''
  107.             pass
  108.  
  109.         m = A()
  110.         
  111.         try:
  112.             exec 'z = a' in g, m
  113.         except TypeError:
  114.             pass
  115.  
  116.         self.fail('Did not validate locals as a mapping')
  117.         
  118.         class D(dict):
  119.             
  120.             def __getitem__(self, key):
  121.                 if key == 'a':
  122.                     return 12
  123.                 
  124.                 return dict.__getitem__(self, key)
  125.  
  126.  
  127.         d = D()
  128.         exec 'z = a' in g, d
  129.         self.assertEqual(d['z'], 12)
  130.  
  131.     
  132.     def test_complex_args(self):
  133.         
  134.         def comp_args(.0):
  135.             (a, b) = .0
  136.             return (a, b)
  137.  
  138.         self.assertEqual(comp_args((1, 2)), (1, 2))
  139.         
  140.         def comp_args(.0 = (3, 4)):
  141.             (a, b) = .0
  142.             return (a, b)
  143.  
  144.         self.assertEqual(comp_args((1, 2)), (1, 2))
  145.         self.assertEqual(comp_args(), (3, 4))
  146.         
  147.         def comp_args(a, .2):
  148.             (b, c) = .2
  149.             return (a, b, c)
  150.  
  151.         self.assertEqual(comp_args(1, (2, 3)), (1, 2, 3))
  152.         
  153.         def comp_args(a = 2, .4 = (3, 4)):
  154.             (b, c) = .4
  155.             return (a, b, c)
  156.  
  157.         self.assertEqual(comp_args(1, (2, 3)), (1, 2, 3))
  158.         self.assertEqual(comp_args(), (2, 3, 4))
  159.  
  160.     
  161.     def test_argument_order(self):
  162.         
  163.         try:
  164.             exec 'def f(a=1, (b, c)): pass'
  165.             self.fail('non-default args after default')
  166.         except SyntaxError:
  167.             pass
  168.  
  169.  
  170.     
  171.     def test_float_literals(self):
  172.         self.assertRaises(SyntaxError, eval, '2e')
  173.         self.assertRaises(SyntaxError, eval, '2.0e+')
  174.         self.assertRaises(SyntaxError, eval, '1e-')
  175.         self.assertRaises(SyntaxError, eval, '3-4e/21')
  176.  
  177.     
  178.     def test_indentation(self):
  179.         s = '\nif 1:\n    if 2:\n        pass'
  180.         compile(s, '<string>', 'exec')
  181.  
  182.     
  183.     def test_literals_with_leading_zeroes(self):
  184.         for arg in [
  185.             '077787',
  186.             '0xj',
  187.             '0x.',
  188.             '0e',
  189.             '090000000000000',
  190.             '080000000000000',
  191.             '000000000000009',
  192.             '000000000000008']:
  193.             self.assertRaises(SyntaxError, eval, arg)
  194.         
  195.         self.assertEqual(eval('0777'), 511)
  196.         self.assertEqual(eval('0777L'), 511)
  197.         self.assertEqual(eval('000777'), 511)
  198.         self.assertEqual(eval('0xff'), 255)
  199.         self.assertEqual(eval('0xffL'), 255)
  200.         self.assertEqual(eval('0XfF'), 255)
  201.         self.assertEqual(eval('0777.'), 777)
  202.         self.assertEqual(eval('0777.0'), 777)
  203.         self.assertEqual(eval('000000000000000000000000000000000000000000000000000777e0'), 777)
  204.         self.assertEqual(eval('0777e1'), 7770)
  205.         self.assertEqual(eval('0e0'), 0)
  206.         self.assertEqual(eval('0000E-012'), 0)
  207.         self.assertEqual(eval('09.5'), 9.5)
  208.         self.assertEqual(eval('0777j'), (0.0+777.0j))
  209.         self.assertEqual(eval('00j'), (0.0+0.0j))
  210.         self.assertEqual(eval('00.0'), 0)
  211.         self.assertEqual(eval('0e3'), 0)
  212.         self.assertEqual(eval('090000000000000.'), 90000000000000.0)
  213.         self.assertEqual(eval('090000000000000.0000000000000000000000'), 90000000000000.0)
  214.         self.assertEqual(eval('090000000000000e0'), 90000000000000.0)
  215.         self.assertEqual(eval('090000000000000e-0'), 90000000000000.0)
  216.         self.assertEqual(eval('090000000000000j'), (0.0+90000000000000.0j))
  217.         self.assertEqual(eval('000000000000007'), 7)
  218.         self.assertEqual(eval('000000000000008.'), 8.0)
  219.         self.assertEqual(eval('000000000000009.'), 9.0)
  220.  
  221.     
  222.     def test_unary_minus(self):
  223.         if sys.maxint == 2147483647:
  224.             all_one_bits = '0xffffffff'
  225.             self.assertEqual(eval(all_one_bits), 0xFFFFFFFFL)
  226.             self.assertEqual(eval('-' + all_one_bits), -0xFFFFFFFFL)
  227.         elif sys.maxint == 0x7FFFFFFFFFFFFFFFL:
  228.             all_one_bits = '0xffffffffffffffff'
  229.             self.assertEqual(eval(all_one_bits), 0xFFFFFFFFFFFFFFFFL)
  230.             self.assertEqual(eval('-' + all_one_bits), -0xFFFFFFFFFFFFFFFFL)
  231.         else:
  232.             self.fail('How many bits *does* this machine have???')
  233.  
  234.     
  235.     def test_sequence_unpacking_error(self):
  236.         if not (1, -1):
  237.             pass
  238.         (i, j) = (-1, 1)
  239.         self.assertEqual(i, 1)
  240.         self.assertEqual(j, -1)
  241.  
  242.     
  243.     def test_none_assignment(self):
  244.         stmts = [
  245.             'None = 0',
  246.             'None += 0',
  247.             '__builtins__.None = 0',
  248.             'def None(): pass',
  249.             'class None: pass',
  250.             '(a, None) = 0, 0',
  251.             'for None in range(10): pass',
  252.             'def f(None): pass']
  253.         for stmt in stmts:
  254.             stmt += '\n'
  255.             self.assertRaises(SyntaxError, compile, stmt, 'tmp', 'single')
  256.             self.assertRaises(SyntaxError, compile, stmt, 'tmp', 'exec')
  257.         
  258.  
  259.     
  260.     def test_import(self):
  261.         succeed = [
  262.             'import sys',
  263.             'import os, sys',
  264.             'from __future__ import nested_scopes, generators',
  265.             'from __future__ import (nested_scopes,\ngenerators)',
  266.             'from __future__ import (nested_scopes,\ngenerators,)',
  267.             'from sys import stdin, stderr, stdout',
  268.             'from sys import (stdin, stderr,\nstdout)',
  269.             'from sys import (stdin, stderr,\nstdout,)',
  270.             'from sys import (stdin\n, stderr, stdout)',
  271.             'from sys import (stdin\n, stderr, stdout,)',
  272.             'from sys import stdin as si, stdout as so, stderr as se',
  273.             'from sys import (stdin as si, stdout as so, stderr as se)',
  274.             'from sys import (stdin as si, stdout as so, stderr as se,)']
  275.         fail = [
  276.             'import (os, sys)',
  277.             'import (os), (sys)',
  278.             'import ((os), (sys))',
  279.             'import (sys',
  280.             'import sys)',
  281.             'import (os,)',
  282.             'from (sys) import stdin',
  283.             'from __future__ import (nested_scopes',
  284.             'from __future__ import nested_scopes)',
  285.             'from __future__ import nested_scopes,\ngenerators',
  286.             'from sys import (stdin',
  287.             'from sys import stdin)',
  288.             'from sys import stdin, stdout,\nstderr',
  289.             'from sys import stdin si',
  290.             'from sys import stdin,from sys import (*)',
  291.             'from sys import (stdin,, stdout, stderr)',
  292.             'from sys import (stdin, stdout),']
  293.         for stmt in succeed:
  294.             compile(stmt, 'tmp', 'exec')
  295.         
  296.         for stmt in fail:
  297.             self.assertRaises(SyntaxError, compile, stmt, 'tmp', 'exec')
  298.         
  299.  
  300.     
  301.     def test_for_distinct_code_objects(self):
  302.         
  303.         def f():
  304.             
  305.             f1 = lambda x = 1: x
  306.             
  307.             f2 = lambda x = 2: x
  308.             return (f1, f2)
  309.  
  310.         (f1, f2) = f()
  311.         self.assertNotEqual(id(f1.func_code), id(f2.func_code))
  312.  
  313.  
  314.  
  315. def test_main():
  316.     test_support.run_unittest(TestSpecifics)
  317.  
  318. if __name__ == '__main__':
  319.     test_main()
  320.  
  321.